Statically-allocated languages for hardware

Current HDLs present a very low level of abstraction, often requiring the designer to work on details that could be hidden, and leaving little scope for synthesis tools to optimise performance. High-level hardware descriptions thus have a useful rôle in EDA, especially in areas such as rapid development, and reconfigurable computing using devices such as FPGAs. One approach to implementing these high-level description languages is to use software-like languages to describe hardware, with synthesis tools that will convert these “programs” to netlists. Such an approach can allow non-experts to design hardware, increase the productivity of more seasoned users, and increase the flexibility of the implementation by tying it to fewer low-level details. The synthesis tools can apply a wider range of optimisations, at a higher level of abstraction. This paper covers such a language, called SASL. It is based on the SAFL [9, 8, 12] language, which is a simple functional programming language designed for implementation in hardware. The aim of SASL is to extend the software-like language features available to hardware designers. By introducing features such as algebraic datatypes and lazy lists, it should be possible to raise the level of abstraction at which designs are produced. It is hoped that such designs could then be synthesised to efficient pipelined hardware, by mapping lazy lists to sequences of data items, for example. To require no external memory, the language is statically-allocated. Recursive data structures are not allowed, and the only form of recursion allowed is tail-recursion, to prevent the need for a dynamically allocated stack. While it would be possible to synthesise circuits that access memories, to allow for more general purpose computation, this could lead to the introduction of von Neumann bottlenecks. The synthesis aims are to improve performance over a software implementation, not only by providing more parallelism, but by holding data closer to the hardware which performs operations on it. SASL is a pure functional language. Functional programming languages provide a relatively abstract way of describing algorithms, and may provide less of a bias towards an implementation based on sequential computation than many other programming language paradigms. Functional languages also provide a wealth of program transformations and optimisations which seem suited to the creation of useful design trade-offs at the synthesis stage. As a simple first-order pure functional language, SAFL’s I/O capabilities are very limited. The language SAFL+[12] has extended the language to include channels, similar to those used in Occam [11] and Handel-C [4]. With channels, the programmer must be aware of the parallelism, and expressions may have side effects. This paper investigates the use of streams, which we believe are a simpler and more natural way of representing I/O for hardware communication. Streams are linear lazy lists. They provide an ordered, possibly infinite, list of data items, each of which can only be read once. The items of data are generated on demand. This form